home *** CD-ROM | disk | FTP | other *** search
/ The X-Philes (2nd Revision) / The X-Philes Number 1 (1995).iso / xphiles / hp48_2 / star-1_0.tar / starsym.c < prev    next >
C/C++ Source or Header  |  1991-03-22  |  5KB  |  181 lines
  1. /* starsym.c -- STAR-Dependent Symbol Table Operations
  2.  
  3. This file is part of STAR, the Saturn Macro Assembler.
  4.  
  5.    STAR is not distributed by the Free Software Foundation. Do not ask
  6. them for a copy or how to obtain new releases. Instead, send e-mail to
  7. the address below. STAR is merely covered by the GNU General Public
  8. License.
  9.  
  10. Please send your comments, ideas, and bug reports to
  11. Jan Brittenson <bson@ai.mit.edu>
  12.  
  13. */
  14.  
  15.  
  16. /* Copyright (C) 1991 Jan Brittenson.
  17.  
  18.    STAR is free software; you can redistribute it and/or modify it
  19. under the terms of the GNU General Public License as published by the
  20. Free Software Foundation; either version 1, or (at your option) any
  21. later version.
  22.  
  23.    STAR is distributed in the hope that it will be useful, but WITHOUT
  24. ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  25. FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
  26. for more details.
  27.  
  28.    You should have received a copy of the GNU General Public License
  29. along with STAR; see the file COPYING. If not, to obtain a copy, write
  30. to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139,
  31. USA, or send e-mail to bson@ai.mit.edu. */
  32.  
  33. #include <stdio.h>
  34. #include "sects.h"
  35. #include "star.h"
  36. #include "symbols.h"
  37.  
  38.  
  39. SYM_NODE
  40.   *sym_list,            /* `LIST' symbol */
  41.   *sym_stdsect,            /* `STDSECT' symbol */
  42.   *sym_cursect;            /* `SECT' symbol */
  43.  
  44.  
  45. SYM_ROOT
  46.   *symtbl;            /* Global symbol table */
  47.  
  48. int
  49.   nhidden;            /* # of hidden symbols (at end of run) */
  50.  
  51.  
  52. extern char *malloc();
  53. extern void free();
  54.  
  55.  
  56. /* Initialize symbol table */
  57. initsym()
  58. { 
  59.   struct val v;
  60.   extern double version_real;
  61.   extern SECT *stdsect;
  62.   
  63.   
  64.   /* Create symbol table root */
  65.   symtbl = sm_open(malloc, free);
  66.  
  67.   v.type = VT_INT;
  68.   v.vint = 48;
  69.  
  70.   sm_enter_sym(symtbl, "SATURN", v, F_REF+F_HID);
  71.  
  72.   sm_enter_sym(symtbl, "MP", intval(3), F_HID+F_REF);
  73.   sm_enter_sym(symtbl, "SR", intval(2), F_HID+F_REF);
  74.   sm_enter_sym(symtbl, "SB", intval(1), F_HID+F_REF);
  75.   sm_enter_sym(symtbl, "XM", intval(0), F_HID+F_REF);
  76.   sm_enter_sym(symtbl, "VERSION", realval(version_real), F_HID+F_REF);
  77.  
  78.   sm_enter_sym(symtbl, "PI", realval(3.14159265358979323846), F_HID+F_REF);
  79.   sm_enter_sym(symtbl, "LN2", realval(0.69314718055994530942), F_HID+F_REF);
  80.   sm_enter_sym(symtbl, "SQRT2", realval(1.41421356237309504880), F_HID+F_REF);
  81.   sm_enter_sym(symtbl, "E", realval(2.7182818284590452354), F_HID+F_REF);
  82.   sm_enter_sym(symtbl, "LOG2E", realval(1.4426950408889634074), F_HID+F_REF);
  83.   sm_enter_sym(symtbl, "LOG10E", realval(0.43429448190325182765), F_HID+F_REF);
  84.   sm_enter_sym(symtbl, "LN10", realval(2.30258509299404568402), F_HID+F_REF);
  85.  
  86.   sym_list = sm_enter_sym(symtbl, "LIST", intval(1), F_HID+F_REF);
  87.   sym_stdsect = sm_enter_sym(symtbl, "STDSECT", val_zero, F_HID+F_REF);
  88.   sym_cursect = sm_enter_sym(symtbl, "SECT", val_zero, F_HID+F_REF);
  89.  
  90.   sym_cursect->value.type = sym_stdsect->value.type = VT_SECT;
  91.  
  92.   sym_cursect->value.vsect = sym_stdsect->value.vsect= stdsect;
  93.   stdsect->sc_symbol = sym_stdsect;
  94.  
  95.   sm_enter_sym(symtbl, "BITS", intval(sizeof(INT)*8), F_HID+F_REF);
  96. }
  97.  
  98.  
  99. /* Add symbol, as undefined, if not in symbol table */
  100. SYM_NODE *symref(symid)
  101.   char *symid;
  102. {
  103.   SYM_NODE *sym;
  104.  
  105.   /* Simply return it if it already exists */
  106.   if(sym = sm_find_sym(symtbl, symid))
  107.     return(sym);
  108.  
  109.   /* Otherwise create it, but mark as unbound */
  110.   return(sm_enter_sym(symtbl, symid, val_zero, F_UDF));
  111. }
  112.  
  113.  
  114. /* Compare two reference entries for qsort */
  115. static refcmp(r1, r2)
  116.   SYM_NODE **r1, **r2;
  117. {
  118.   extern scmp();
  119.  
  120.   return(scmp((*r1)->name, (*r2)->name));
  121. }
  122.  
  123.  
  124. /* Add symbol tree to reference array */
  125. static void add_sym_to_table(symp, slot, nsymp)
  126.   SYM_NODE *symp, ***slot;
  127.   int *nsymp;
  128. {
  129.   for(; symp; symp = symp->sgt)
  130.     {
  131.       /* Add less-than branch */
  132.       if(symp->slt)
  133.     add_sym_to_table(symp->slt, slot, nsymp);
  134.       
  135.       /* Update statistics */
  136.       if(symp->flags & (F_UDF|F_HID) == F_HID)
  137.     nhidden++;
  138.  
  139.       /* Add this node */
  140.       if(!(symp->flags & (F_UDF | F_HID)) &&
  141.      !(symp->name[0] == 'L' && symp->name[1] == '_'))
  142.     {
  143.       *(*slot)++ = symp;
  144.       (*nsymp)++;
  145.     }
  146.     }
  147. }
  148.  
  149.  
  150. /* Return symbol table reference, suitable for printing */
  151. SYM_NODE **create_sym_ref(nsymp)
  152.   int *nsymp;
  153. {
  154.   SYM_NODE **refarr, **curslot, **curhash;
  155.   extern char *malloc();
  156.  
  157.  
  158.   /* Allocate reference array */
  159.   if(!(refarr = (SYM_NODE **) malloc(symtbl->nsymbols * sizeof(SYM_ROOT **))))
  160.     fatal("Can't allocate %d bytes for symbol table reference",
  161.       symtbl->nsymbols * sizeof(SYM_ROOT));
  162.  
  163.  
  164.   /* Add references tree by tree */
  165.   for(*nsymp = 0,
  166.       curslot = refarr,
  167.       curhash = symtbl->sm_slot,
  168.       nhidden = 0;
  169.  
  170.       curhash < symtbl->sm_slot + SYM_NHASH;
  171.  
  172.       add_sym_to_table(*curhash++, &curslot, nsymp));
  173.  
  174.  
  175.   /* Sort the reference array */
  176.   qsort((char *) refarr, *nsymp, sizeof(SYM_NODE *), refcmp);
  177.  
  178.   /* Return it */
  179.   return(refarr);
  180. }
  181.